Fox's Git Mirrors
Node / rns-mirrors / Reticulum-Go.git rns://e35de29a61974cd952fde3fe9c8500d5/rns-mirrors/Reticulum-Go.git
>Reticulum-Go
Reticulum-Go is a high-performance and secure Golang implementation of the Reticulum Network Stack. It is intended to strengthen the existing networks and bring Reticulum to more devices not to replace the python reference implementation.
Available on rngit:
NomadNet Node: T383838132f67e79d9b24aad014e93015fb858f:/page/index.mu
T383838git clone rns://06a54b505bb67b25ef3f8097e8001edc/public/Reticulum-Go
Overview
Reticulum-Go provides full protocol compatibility with the Python reference implementation. It leverages the Go concurrency model to deliver improved throughput and lower latency. The implementation is designed for cross-platform deployment across both modern and legacy systems.
For details on interoperability, see COMPATIBILITY.md. You can find the canonical network API reference at the Reticulum Manual.
Documentation Index
• Full English Documentation: docs/en/
• For Application Authors: API Reference and Examples
• Additional Languages: Translations will live alongside T383838docs/en/ as they become available.
Main Goals
• Excellent portability and support for legacy operating systems
• Clear auditability and supply chain security
• Full protocol interoperability with the Python reference implementation and its standard utilities
• High performance using modern Go concurrency patterns and optimized code
• High security with native sandboxing and firecracker microvm support
• Reliable operation with reconnect, NIC watching, and interface hot reload
Features
┌───────────────────────────────┬───────────────────────┬──────────────────────────────────────────┐
│ Functional Area │ Implementation Status │ Notes │
├───────────────────────────────┼───────────────────────┼──────────────────────────────────────────┤
│ Protocol Compatibility │ Yes │ Full wire compatibility with the Python… │
│ Daemon and Utilities │ Yes │ Provided via a single T383838reticulum-go bina… │
│ Core Network Stack │ Yes │ Includes packet processing, transport, … │
│ Links and Channels │ Yes │ Full support for links, resources, chan… │
│ Cryptography │ Yes │ Centralized in T383838pkg/cryptography. See !. Application code should use T383838pkg/cryptography and T383838pkg/identity rather than writing ad hoc cryptographic operations.
Runtime Sandbox
The T383838reticulum-go daemon applies a platform-specific sandbox after startup. The sandbox is on by default. You can disable it by adding this option to your configuration file:
T282828
enable_sandbox = no
Depending on your platform, the sandbox uses different isolation mechanisms:
• Linux: Landlock (kernel 5.13+) restricts filesystem access to the folders the daemon needs, then a soft-fail seccomp-bpf denylist blocks high-risk syscalls.
• OpenBSD: Uses unveil and pledge to limit system and file operations.
• FreeBSD: Enters capability mode to isolate the process.
• Windows: Applies job-object limits to control system resources.
Refer to SECURITY.md for details and specific platform limitations.
Requirements
• Go version 1.26.5 or later
• Optional for Odin bindings: Odin compiler on T383838PATH (CI pins T383838dev-2026-06), plus CGO to build T383838librns.so
• Optional for Zig bindings: Zig compiler on T383838PATH (CI pins T3838380.16.0), plus CGO to build T383838librns.so
• Optional for Dart / Flutter bindings: Dart SDK on T383838PATH (CI pins T3838383.11.4). FFI tests also need CGO to build T383838librns.so
• Optional for Lua bindings: LuaJIT on T383838PATH, plus CGO to build T383838librns.so
• Optional for Swift bindings: Swift toolchain on T383838PATH (CI pins T3838386.0.3), plus CGO to build T383838librns.so
• Optional for Java bindings: JDK with T383838javac on T383838PATH (CI uses Temurin 17), plus CGO to build T383838librns.so
• Optional for Kotlin bindings: T383838kotlinc on T383838PATH (CI pins T3838382.1.10) and a JDK, plus CGO to build T383838librns.so
Quick Start
You can use the provided Makefile targets or run the equivalent go commands directly if you do not have Make installed.
Build
Compile the native binary:
T282828
make build
Or build manually using Go:
T282828
mkdir -p bin
CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/reticulum-go ./cmd/reticulum-go
The output binary will be created at T383838bin/reticulum-go.
Install
Install the main binary, legacy tool symlinks (such as rgostatus and rgoid), and man pages to the default prefix T383838/usr/local:
T282828
make install
To use a custom installation directory:
T282828
make install PREFIX=/opt/reticulum
To stage files for package managers:
T282828
make install DESTDIR=/tmp/stage PREFIX=/usr
Install as a service
Install init service files for the detected init system (or set T383838INIT):
T282828
make install-service
make install-service INIT=systemd
make install-service INIT=openrc
make install-service INIT=runit
make install-service INIT=dinit
make install-service INIT=all
Service units live under packaging/ (systemd, openrc, runit, dinit). The install creates T383838/var/lib/reticulum-go/ with a sample config that logs to both stderr and T383838/var/lib/reticulum-go/logfile/reticulum.log.
Alternatively, install directly into your Go binary directory:
T282828
CGO_ENABLED=0 go install -ldflags="-s -w" ./cmd/reticulum-go
Packaging
Build T383838.deb, T383838.rpm, or T383838.pkg.tar.zst packages using nfpm. The tool is fetched on demand:
T282828
make package-deb
make package-rpm
make package-arch
The package files are placed in the T383838dist/ folder. The packaging options are configured in packaging/nfpm.yaml.
Command Usage
Run the main daemon or query status and paths:
T282828
reticulum-go # Starts the background daemon
reticulum-go status # Displays interface statistics
reticulum-go slow # Bottleneck and local health findings
reticulum-go id -h # Shows identity options
reticulum-go probe ... # Proves path reachability
reticulum-go path -t # Inspects known paths
reticulum-go cp -l # Handles copy operations
reticulum-go x -l # Executes remote commands
reticulum-go pageserver # Runs the built-in page server
You can view the documentation by running manual commands:
• T383838man reticulum-go
• T383838man 8 reticulum-go
• T383838man reticulum-go-status
• T383838man reticulum-go-slow
Run from Source
Run the daemon directly from the source code:
T282828
make run
Or run manually:
T282828
go run ./cmd/reticulum-go
Run Tests
Run the full test suite:
T282828
make test
Host OS preflight (sandbox, interfaces, short daemon):
T282828
make test-self-check
Or run manually:
T282828
go test -v ./...
Makefile Reference
┌──────────────────────────────┬─────────────────────────────────────────────────────────────┬─────┐
│ Target │ Description │ Eq… │
├──────────────────────────────┼─────────────────────────────────────────────────────────────┼─────┤
│ make / T383838make all │ Compiles the release binary. │ Ma… │
│ T383838make build │ Compiles a stripped, static release binary. │ T383838CG… │
│ T383838make build-utils │ Alias for building the main binary. │ Su… │
│ T383838make install │ Installs the binary, legacy symlinks, and man pages. │ In… │
│ T383838make install-man │ Installs only the manual pages. │ In… │
│ T383838make install-service │ Installs systemd, openrc, runit, and/or dinit service file… │ … │
│ T383838make package-deb │ Builds a Debian package. │ Ou… │
│ T383838make package-rpm │ Builds an RPM package. │ Ou… │
│ T383838make package-arch │ Builds an Arch Linux package. │ Ou… │
│ T383838make uninstall │ Removes the binary, symlinks, and man pages. │ De… │
│ T383838make clean │ Deletes build and test artifacts. │ Ru… │
│ T383838make test │ Runs the full test suite. │ Ru… │
│ T383838make test-short │ Runs only short unit tests. │ Ru… │
│ T383838make test-race │ Runs tests with the Go race detector enabled. │ Ru… │
│ T383838make test-services │ Docker tests for logfile + systemd/openrc/runit/dinit serv… │ Ru… │
│ T383838make test-self-check │ Host OS preflight for reticulum-go platform features. │ Ru… │
│ T383838make test-self-check-386 │ Linux 386 self-check under qemu-user. │ Ru… │
│ T383838make test-self-check-arm │ Linux arm (GOARM=6) self-check under qemu-user. │ Ru… │
│ T383838make test-self-check-riscv64 │ Linux riscv64 self-check under qemu-user. │ Ru… │
│ T383838make test-self-check-ppc64le │ Linux ppc64le self-check under qemu-user. │ Ru… │
│ T383838make test-self-check-ppc64 │ Linux ppc64 (big-endian) self-check under qemu-user. │ Ru… │
│ T383838make coverage │ Generates and opens a test coverage report. │ Ru… │
│ T383838make bench │ Runs all benchmark tests. │ Ru… │
│ T383838make fmt │ Formats all Go source files. │ Ru… │
│ T383838make vet │ Runs the standard Go vet tool. │ Ru… │
│ T383838make lint │ Runs the revive linter. │ Ru… │
│ T383838make vulncheck │ Runs govulncheck. │ Ru… │
│ T383838make check │ Runs formatting, vetting, linting, short tests, and vulnch… │ Ru… │
│ T383838make deps │ Downloads and verifies Go modules. │ Ru… │
│ T383838make run │ Compiles and runs the daemon. │ Ru… │
│ T383838make debug │ Compiles a standard debug binary with symbols. │ Ru… │
│ T383838make microvm-up │ Prepare and start Firecracker microvm + host bridge. │ Ru… │
│ T383838make microvm-stop │ Stop Firecracker microvm and host bridge. │ Ru… │
│ T383838make build-linux │ Cross-compiles for Linux. │ Cr… │
│ T383838make build-windows │ Cross-compiles for Windows. │ Cr… │
│ T383838make build-windows-legacy │ Cross-compiles for legacy Windows releases. │ Co… │
│ T383838make build-darwin │ Cross-compiles for macOS. │ Cr… │
│ T383838make build-all │ Cross-compiles for all major platforms. │ Co… │
│ T383838make tree-rsm-verify │ Verifies T383838reticulum-go.rsm signature and file hashes. │ T383838sh… │
│ T383838make tree-rsm-sign │ Signs the tree inventory into T383838reticulum-go.rsm. │ Re… │
│ T383838make hooks-install │ Enables the tracked pre-commit hook (YAML/shellcheck + RSM… │ T383838sh… │
└──────────────────────────────┴─────────────────────────────────────────────────────────────┴─────┘
Taskfile Automation
The project provides a Taskfile for advanced local automation. If you have Task installed, run T383838task --list to view all available tasks.
T282828
task build
task install
task test
On some Linux distributions, the command is named T383838go-task instead of task. You can add an alias to your shell profile if needed:
T282828
alias task='go-task'
Development and Contributions
Code Quality Checks
Run the verification suite before submitting pull requests:
T282828
make fmt
make vet
make lint
make check
These targets format code, run static analysis, check for common linter issues, and run short tests to ensure regressions are not introduced.
Cross-Platform Builds
Verify cross-compilation across platforms:
T282828
make build-linux
make build-windows
make build-darwin
make build-all
Cross-compilation uses the same optimization flags as native builds. See the Makefile targets for exact environmental variables.
Windows 7, 8, and 8.1 Support
Official Go 1.21 and newer releases no longer support Windows 7. To support legacy deployments, we compile our legacy Windows releases using go-legacy-win7. This maintained fork restores compatibility with Windows 7, 8, 8.1, Server 2008 R2, and Server 2012 R2.
Official tagged releases include T383838reticulum-go-windows-amd64-win7.exe and T383838reticulum-go-windows-arm64-win7.exe binaries. These files run on both modern and legacy Windows installations.
To compile legacy Windows binaries locally, install go-legacy-win7 and run:
T282828
make build-windows-legacy
Or build using Task:
T282828
task build-windows-legacy
You can also specify a custom path to your legacy Go compiler:
T282828
GO_LEGACY_WIN7=/usr/local/go-legacy-win7/bin/go make build-windows-legacy
CI uses a pinned Go 1.26.5 compiler via GitHub Actions. Legacy Windows builds use T383838scripts/ci/setup-go-legacy-win7.sh to download and verify the legacy compiler.
WebAssembly and Embedded Targets
To compile the WebAssembly binary, run the following Task commands:
T282828
task build-wasm
task test-wasm
librns Shared Library
For in-process embedding in C, C++, and Python (FFI), we provide a C ABI target. The main daemon is built with T383838CGO_ENABLED=0, but the shared library compilation requires CGO.
To build the shared library:
T282828
task build-librns
make -C bindings/c/examples/smoke
./bindings/c/examples/smoke/librns-smoke
This compiles the shared library to T383838bin/librns.so and generates header definitions at T383838include/rns.h. For details, see docs/en/librns.md.
Odin Bindings
Idiomatic Odin wrappers over T383838librns.so live in T383838bindings/odin. Requires the Odin compiler on T383838PATH.
T282828
task build-librns
task test-odin
Covers node lifecycle, identity, destinations, paths, links, and events. Details: docs/en/librns.md.
Zig Bindings
Idiomatic Zig wrappers over T383838librns.so live in T383838bindings/zig. Requires Zig 0.16.0 or later on T383838PATH.
T282828
task build-librns
task test-zig
Covers the same ABI surface as the Odin bindings. Details: docs/en/librns.md.
C++ Bindings
Idiomatic C++17 RAII wrappers over T383838librns.so live in T383838bindings/cpp. Requires CMake and a C++17 compiler.
T282828
task build-librns
task test-cpp
Covers the same ABI surface as the Odin and Zig bindings. Details: docs/en/librns.md.
Rust Bindings
Safe Rust wrappers over T383838librns.so live in T383838bindings/rust. Requires T383838cargo on T383838PATH.
T282828
task build-librns
task test-rust
Details: docs/en/librns.md.
Python Bindings
ctypes wrappers over T383838librns.so live in T383838bindings/python.
T282828
task build-librns
task test-python
Details: docs/en/librns.md.
Lua Bindings
LuaJIT FFI wrappers over T383838librns.so live in T383838bindings/lua.
T282828
task build-librns
task test-lua
Details: docs/en/librns.md.
Swift Bindings
SwiftPM wrappers over T383838librns.so live in T383838bindings/swift.
T282828
task build-librns
task test-swift
Details: docs/en/librns.md.
Java Bindings
JNA wrappers over T383838librns.so live in T383838bindings/java.
T282828
task build-librns
task test-java
Details: docs/en/librns.md.
Kotlin Bindings
Kotlin facade over the Java JNA bindings lives in T383838bindings/kotlin.
T282828
task build-librns
task test-kotlin
Details: docs/en/librns.md.
Dart / Flutter Bindings
Package rns_control in T383838bindings/dart provides:
• In-process librns FFI (T383838package:rns_control/ffi.dart) on Linux, Android, and Windows
• Control API HTTP and WebSocket client for a running daemon
T282828
task build-librns
task test-dart
# cross-build native libraries
task build-librns-targets -- linux android windows
Details: docs/en/librns.md and docs/en/control-api.md.
If you are compiling for TinyGo and small microcontroller boards, check out our tinygo branch. This requires TinyGo version 0.41.0 or newer.
Vendored Dependencies and Offline Builds
Why We Vendor Dependencies
We fully vendor all third-party dependencies. The source trees are stored inside the T383838vendor/ directory of this repository. This approach provides several key benefits:
• Build Reliability: Compilation and testing do not depend on downloading external modules. This allows you to build the project in completely air-gapped or offline environments.
• Release Stability: Release builds do not rely on the public availability of module proxies or upstream hosting platforms.
• Auditability and Security: Every dependency change or upgrade appears as a standard file diff in pull requests. This makes it straightforward to inspect third-party changes during code audits.
• Supply Chain Control: Normal builds compile the exact source code committed in the repository, protecting you against upstream dependency attacks.
Versions and checksums are still officially tracked inside the T383838go.mod and T383838go.sum files. The T383838vendor/ directories serve as the canonical source copy for our compilers.
Offline Build Configurations
The continuous integration pipeline uses these identical flags. The only exception is scripts that install standalone CLI tools, such as revive or gosec in our setup scripts. These temporary installation tasks temporarily clear the environment flags to fetch the binary tools, but the actual project code is always compiled from the local T383838vendor/ folder.
Synchronizing Sibling Libraries
If you are developing first-party libraries under T383838Reticulum-Go-Projects/, you can synchronize imports using:
T282828
task vendor-sync
Alternatively, run:
T282828
make deps
Set the T383838LIBS_ROOT environment variable to point to your local libraries repository. This command will update the replace paths in T383838go.mod and update the vendor folders. Make sure to commit the updated T383838go.mod, T383838go.sum, and updated T383838vendor/ trees.
Ordinary source checkouts only need the T383838vendor/ directories to build offline. Sibling repository checkouts are only required if you are actively updating or re-vendoring first-party libraries.
The T383838examples/wasm and T383838examples/pageserver examples contain their own independent T383838go.mod and T383838vendor/ files. The Docker configurations under T383838docker/ copy these folders to build matching containers offline.
AI Disclaimer
Open-weight LLMs, preferably operated locally under a controlled harness, may assist with non-critical tasks such as commit messages, documentation, drafts, translations, and tests. LLMs are strictly excluded from cryptography, key handling, protocol security logic, and any other security-sensitive development. All LLM output is reviewed and approved by a human. Design decisions and security-critical changes are made exclusively by humans.
Credit
License
Served by rngit 1.4.1 - Generated in 0.09s